package cn.tedu.csmall.product.service.impl;

import cn.tedu.csmall.product.ex.ServiceException;
import cn.tedu.csmall.product.mapper.BrandCategoryMapper;
import cn.tedu.csmall.product.mapper.CategoryAttributeTemplateMapper;
import cn.tedu.csmall.product.mapper.CategoryMapper;
import cn.tedu.csmall.product.mapper.SpuMapper;
import cn.tedu.csmall.product.pojo.VO.CategoryListVO;
import cn.tedu.csmall.product.pojo.VO.CategoryStandardVO;
import cn.tedu.csmall.product.pojo.dto.CategoryAddNewDTO;
import cn.tedu.csmall.product.pojo.entity.Category;
import cn.tedu.csmall.product.service.ICategoryService;
import cn.tedu.csmall.product.web.ServiceCode;
import com.sun.org.apache.bcel.internal.generic.ATHROW;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Slf4j
public class CategoryServiceImpl implements ICategoryService {
    @Autowired
    private CategoryMapper categoryMapper;
    @Autowired
    private BrandCategoryMapper brandCategoryMapper;
    @Autowired
    private CategoryAttributeTemplateMapper categoryAttributeTemplateMapper;
    @Autowired
    private SpuMapper spuMapper;
    @Override

    @Transactional
    public void addNew(CategoryAddNewDTO categoryAddNewDTO) {
        //调用mapper对象的countName方法，检查名称是否被占用
        String name = categoryAddNewDTO.getName();
        int countByName = categoryMapper.countByName(name);
        if(countByName>0){
            // 是：抛出异常（ERR_CONFLICT）
            String message = "添加类别失败，类别名称被占用";
            log.debug(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
        }
        Integer depth = 1;
        CategoryStandardVO parentCategory = null;
        Long parentId = categoryAddNewDTO.getParentId();
        if(parentId!=0){
            // 如果parentId不是0，调用Mapper对象的getStandardById()查询类别详情
            parentCategory = categoryMapper.getStandardById(parentId);
            // 判断查询结果是否为null
            if(parentCategory==null){
                String message = "添加失败，父级类别不存在";
                // 是：父级类别不存在，抛出异常（NOT_FOUND）
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
            }
            depth = parentCategory.getDepth()+1;
        }
        // 创建Category类的对象
        Category category = new Category();
        // 将参数对象中的各属性值复制到以上新创建的Category类的对象中
        BeanUtils.copyProperties(categoryAddNewDTO,category);
        // 补全Category类的对象的属性值：depth
        category.setDepth(depth);
        // 补全Category类的对象的属性值：isParent >>> 固定为0
        category.setIsParent(0);
        // 调用Mapper对象的insert()方法插入类别数据
        int rows = categoryMapper.insert(category);
        if(rows!=1){
            String message = "添加类别失败，服务器繁忙，请稍后再试!";
            throw new ServiceException(ServiceCode.ERR_INSERT,message);
        }
        // 如果现在添加的类别的父级类别不是0
        if(parentId!=0){
            // 如果父级类别的isParent仍为0
            if(parentCategory.getIsParent()==0){
                // 则将父级类别的isParent更新为1
                Category updateCategory = new Category();
                updateCategory.setIsParent(1);
                updateCategory.setId(parentId);
                rows = categoryMapper.update(updateCategory);
                if(rows!=1){
                    String message = "添加类别失败，服务器繁忙，请稍后再试!";
                    throw new ServiceException(ServiceCode.ERR_UPDATE,message);
                }
            }
        }
    }

    @Override
    public void deleteById(Long id) {
        CategoryStandardVO standardById = categoryMapper.getStandardById(id);
        // 调用Mapper对象的getStandardById()执行查询
        if(standardById==null){
            // 判断查询结果是否为null
            // 是：数据已经不存在，抛出异常（NOT_FOUND）
            String message = "删除类别失败，数据已经不存在";
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
        }
        if(standardById.getIsParent()==1){
            // 判断以上查询结果中的isParent是否为1
            // 是：当前尝试删除的是父级类别，抛出异常（CONFLICT）
            String message = "删除失败，当前尝试删除的是父级类别";
            throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
        }
        {
            // 调用BrandCategoryMapper对象的countByCategory()执行统计
            int count = brandCategoryMapper.countByCategory(id);
            // 判断统计结果是否大于0
            if (count > 0) {
                // 是：当前尝试删除的类别关联到了某些品牌，抛出异常（CONFLICT）
                String message = "删除失败，当前尝试删除的类别关联到了某些品牌";
                throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
            }
        }
        {
        // 调用CategoryAttributeTemplateMapper对象的countByCategory()执行统计
            int count = categoryAttributeTemplateMapper.countByCategory(id);
            // 判断统计结果是否大于0
            if(count>0){
                // 是：当前尝试删除的类别关联到了某些属性模板，抛出异常（CONFLICT）
                String message = "删除失败，当前尝试删除的类别关联到了某些属性模板";
                throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
            }
        }
        {
            // 调用SpuMapper对象的countByCategory()执行统计
            int count = spuMapper.countByCategory(id);
            // 判断统计结果是否大于0
            if(count>0) {
                // 是：当前尝试删除的类别关联到了某些SPU，抛出异常（CONFLICT）
                String message = "删除失败，当前尝试删除的类别关联到了某些SPU";
                throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
            }
        }
        // 调用Mapper对象的deleteById()执行删除
        int rows = categoryMapper.deleteById(id);
        if(rows!=1){
            String message = "删除类别失败，服务器繁忙，请稍后再试!";
            throw new ServiceException(ServiceCode.ERR_DELETE,message);
        }
        // 从此前的查询结果中找到当前删除的类别的父级类别ID
        Long parentId = standardById.getParentId();
        // 判断父级类别ID是否不为0
        if(parentId!=0){
            // 调用Mapper对象的countByParentId()执行统计
            int count = categoryMapper.countByParentId(parentId);
            // 判断统计结果是否等于0
            if(count == 0){
                // 是：将父级类别的isParent更新为0
                Category parentCategory = new Category();
                parentCategory.setId(parentId);
                parentCategory.setIsParent(0);
                rows = categoryMapper.update(parentCategory);
                if(rows!=1){
                    String message = "删除类别失败，服务器繁忙，请稍后再试!";
                    throw new ServiceException(ServiceCode.ERR_UPDATE,message);
                }
            }
        }
    }

    @Override
    public CategoryStandardVO getStandardById(Long id) {
        log.debug("开始处理根据id：{}查询数据详情的业务",id);
        CategoryStandardVO standardById = categoryMapper.getStandardById(id);
        if (standardById == null) {
            String message = "查询数据失败，该数据不存在";
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
        }
        return standardById;
    }

    @Override
    public List<CategoryListVO> listByParentId(Long id) {
        List<CategoryListVO> lists = categoryMapper.listByParentId(id);
        return lists;
    }

    @Override
    public void setEnable(Long id) {
        updateEnableById(id,1);
    }

    @Override
    public void setDisable(Long id) {
        updateEnableById(id,0);
    }

    private void updateEnableById(Long id, Integer enable) {
        String enableText[] = {"禁用", "启用"};
        // 调用Mapper对象的getStandardById()方法执行查询
        CategoryStandardVO queryResult = categoryMapper.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：抛出异常（NOT_FOUND）
            String message = enableText[enable] + "类别失败，尝试访问的类别数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        // 判断以上查询结果中的enable是否与参数enable相同
        if (queryResult.getEnable() == enable) {
            // 是：抛出异常（CONFLICT）
            String message = "操作错误，该类别已"+enableText[enable];
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }
        // 创建Category对象，并将2个参数的值封装进来
        Category category = new Category();
        category.setId(id);
        category.setEnable(enable);
        // 调用Mapper对象的update()执行更新，并获取返回结果，判断是否符合预期值
        int rows = categoryMapper.update(category);
        if (rows != 1) {
            String message = enableText[enable] + "类别失败，服务器忙，请稍后再次尝试！";
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }


    @Override
    public void setDisplay(Long id) {
        updateDisplay(id,1);
    }

    @Override
    public void NotDisplay(Long id) {
        updateDisplay(id,0);
    }

    private void updateDisplay(Long id, Integer isDisplay){
        String[] str = {"不显示","显示"};
        CategoryStandardVO standardById = categoryMapper.getStandardById(id);
        if(standardById == null){
            String message = str[isDisplay]+"类别失败，该类别不存在";
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
        }
        if (standardById.getIsDisplay() == isDisplay){
            String message = "操作失败，该类别已"+str[isDisplay];
            throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
        }
        Category category =  new Category();
        category.setId(id);
        category.setIsDisplay(isDisplay);
        int update = categoryMapper.update(category);
        if(update != 1){
            String message = "操作异常，当前服务器繁忙，请稍后尝试！";
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }
}
